# encoding:utf-8
import json
import os
import re
import shutil
import time
from helper.ExcelHelp import readExcel_index, writeExcel
import threadpool
from unipath import FILES, Path, DIRS

# 视频文件
video_type = ['.mp4', '.avi', '.rmvb', '.wmv', '.mov', '.mkv', '.flv', '.ts', '.webm', '.iso', '.m2ts', '.mpg', '.m4v']
# 本地路径
local_youma_dir_path = r'E:\emby\有码艺术'
local_wuma_dir_path = r'E:\emby\无码艺术'
local_youma_mapping_dir_path = r'E:\emby\文件映射\有码艺术'
local_wuma_mapping_dir_path = r'E:\emby\文件映射\无码艺术'
cloud_youma_dir_path = r'Y:\115\艺术视频\有码艺术'
cloud_wuma_dir_path = r'Y:\115\艺术视频\无码艺术'
local_json_file_path = r'./scrapy_result/mapping_local.json'


# 读取文本内容
def get_txt_content(file_name):
    result_info = []
    movie_num = ''
    movie_nfo = ''
    try:
        current = 0
        f = open(Path(r"C:\Users\Administrator\.mlogs", file_name + ".txt"), 'r', encoding='utf8')  # 返回一个文件对象
        line = f.readline()  # 调用文件的 readline()方法，一次读取一行
        while line:
            new_line = line.replace("\n", "")
            if new_line == '[*]======================================================':
                movie_num = ''
                movie_nfo = ''
                current = 1
            else:
                current = current + 1

            if current == 3:
                movie_num = re.findall(r".*?'(.*?)'", new_line)[0]
                print(movie_num)

            if new_line.__contains__('.nfo'):
                movie_nfo = new_line.replace("[+]Wrote!            ", "")
                result_info.append((movie_num, movie_nfo))
                print(movie_nfo)

            line = f.readline()
        f.close()
    except Exception as ex:
        print(ex)

    with open('./scrapy_result/jav.json', 'w+', encoding='utf-8') as file:
        file.write(json.dumps(result_info, ensure_ascii=False))


# 增加虚拟文件 已.laoji为后缀的文件
def edit_ext(root_path):
    """
    修改视频文件扩展名
    :param root_path: 根目录路径
    :return:
    """
    # 获取文件夹下的所有文件
    for item in Path(root_path).walk(filter=FILES):
        print("[F]  " + item)
        # 处理文件
        if item.ext.lower() in video_type:
            # 文件名称
            new_file = Path(Path(item).parent, Path(item).name + '.laoji')
            # 如果存在就跳过
            if not new_file.exists():
                # 创建新文件
                file_stream = open(new_file, "wb", buffering=0)
                file_stream.close()
            # 删除旧文件
            # item.remove()


# 通过.laoji的文件创建视频文件
def back_edit_ext(root_path):
    """
    修改视频文件扩展名
    :param root_path: 根目录路径
    :return:
    """
    # 获取文件夹下的所有文件
    for item_file in Path(root_path).walk(filter=FILES):
        # 如果不是.laoji后缀的文件就跳过
        if item_file.ext.lower() not in ['.laoji']:
            continue
        # 如果文件存在就删除
        target_file_path = Path(item_file.parent, item_file.stem)
        if target_file_path.exists():
            target_file_path.remove()
        # 文件已经存在
        if target_file_path.exists():
            print("[!]  " + target_file_path)
            continue
        try:
            print('{} -> {}'.format(item_file, target_file_path.parent))
            Path("./scrapy_result/source_move_file.mkv").copy(target_file_path)
            # file_stream = open(target_file_path, "wb", buffering=0)
            # file_stream.close()
        except Exception as ex:
            print("[#] #################")
            print("[#] " + repr(ex))
            print("[#] #################")
            # targer_file_path.rmtree(True)


# 本地文件和云空间文件映射
def mapping_file_with_json(youma):
    """
    1、本地文件和云空间文件映射
    :param youma: true：有码，false：无码 路径不一样
    :return:
    """
    # 加载数据
    with open(local_json_file_path, 'r', encoding='utf-8') as file:
        will_process_file_mapping = json.load(file)

    # E:\emby\有码艺术\ABF-055\ABF-055.mp4
    for item in will_process_file_mapping:
        # 构建本地路径
        temp_local_dir_path = ""
        temp_cloud_dir_path = ""
        if youma:
            temp_local_dir_path = Path(local_youma_dir_path, item['dir_name'])
            temp_cloud_dir_path = cloud_youma_dir_path
        else:
            temp_local_dir_path = Path(local_wuma_dir_path, item['dir_name'])
            temp_cloud_dir_path = cloud_wuma_dir_path

        # 删除当前文件夹下的软连接
        for item_file_path in Path(temp_local_dir_path).walk(filter=FILES):
            if item_file_path.islink():
                print(item)
                item.remove()

        # 获取所有的视频文件做映射
        for item_file_path in Path(temp_local_dir_path).walk(filter=FILES):
            # 如果是自己标记的文件类型就做处理
            if item_file_path.ext.lower() in ['.laoji']:
                # 还原原始文件名带扩展名
                source_file_name = item_file_path.stem.replace(".laoji", "")

                # 执行命令
                cmd = 'mklink "{}" "{}"'.format(
                    Path(item_file_path.parent, source_file_name),
                    Path(temp_cloud_dir_path, source_file_name)
                )
                os.system(cmd)


def mapping_file_with_video(youma):
    """
    1、本地文件和云空间文件映射
    :param youma: true：有码，false：无码 路径不一样
    :return:
    """
    # 默认无码
    root_dir_path = local_wuma_dir_path
    source_dir_path = local_youma_mapping_dir_path
    target_dir_path = cloud_wuma_dir_path
    if youma:
        root_dir_path = local_youma_dir_path
        source_dir_path = local_youma_mapping_dir_path
        target_dir_path = cloud_youma_dir_path

    # E:\emby\有码艺术\ABF-055\ABF-055.mp4
    # E:\emby\文件映射\有码艺术\ABF-055.mp4
    for item in Path(root_dir_path).walk(filter=FILES):
        print("[F]  " + item)
        # 如果不是视频文件不处理
        if item.ext.lower() not in video_type:
            continue
        # 执行命令
        cmd = 'mklink "{}" "{}"'.format(
            Path(source_dir_path, item.name),
            Path(target_dir_path, item.name)
        )
        os.system(cmd)


def mapping_file_local(source_file_path, targer_file_path):
    # 清空给所有的软连接
    for root, dirs, files in os.walk(source_file_path):
        for file in files:
            path = Path(root, file)
            print("[D] => {}".format(path))
            if path.islink():
                path.remove()

    # 所有源文件
    for item in Path(source_file_path).walk(filter=FILES):
        if item.ext.lower() in ['.laoji']:
            # 执行命令
            cmd = 'mklink "{}" "{}"'.format(Path(item.parent, item.replace(".laoji", "")), targer_file_path)
            os.system(cmd)


# 删除软连接
def remove_lik(source_dir_path):
    # 清空给所有的软连接
    for item in Path(source_dir_path).walk(filter=FILES):
        if item.islink():
            print(item)
            item.remove()


# 检查文件夹里面是否有 fanart、poster、thumb、nfo文件
def check_movie_info(dir_path):
    """
    :param dir_path: 根目录
    """
    dir_path = Path(dir_path)
    dirs = dir_path.listdir()
    count = 0
    count_all = str(len(dirs))
    print('[+]找到 {0} 文件夹'.format(count_all))
    error_list = []
    will_delete_list = []
    for dir_name in dirs:
        count = count + 1
        percentage = str(count / int(count_all) * 100)[:4] + '%'
        print('[!] ------------- ' + percentage + ' [' + str(count) + '/' + count_all + '] ------------- ' + dir_name)
        # 文件夹路径
        nfo_file_list = []
        jpg_file_list = []
        movie_file_list = []

        for item_file_name in dir_name.walk(filter=FILES):
            # nfo文件
            if item_file_name.ext.lower() == '.nfo':
                nfo_file_list.append(item_file_name)
                continue

            # 图片文件
            if item_file_name.ext == '.jpg':
                if item_file_name.name.__contains__("poster") or item_file_name.name.__contains__("fanart") or item_file_name.name.__contains__("thumb"):
                    jpg_file_list.append(item_file_name)
                continue

            # 视频文件
            if Path(item_file_name).ext.lower() in video_type:
                movie_file_list.append(item_file_name)
                continue

            will_delete_list.append(item_file_name)
        try:
            if len(nfo_file_list) == 0 or len(jpg_file_list) < 3 or len(movie_file_list) == 0:
                error_list.append(dir_name)
        except:
            print("  [-] 操作异常")
    print("[*] *****************************************")
    print("[*] **************** 异常文件夹")
    print("[*] *****************************************")
    for item in error_list:
        print("[#] -> {0}".format(item))
    print("[*]============================处理完成==========================")


# 获取最后一级目录
def gci(filepath, targer_file):
    # 遍历filepath下所有文件，包括子目录
    files = os.listdir(filepath)
    exent_dir = False
    for fi in files:
        fi_d = os.path.join(filepath, fi)
        if os.path.isdir(fi_d):
            exent_dir = True
            gci(fi_d, targer_file)
    if not exent_dir:
        print("[-->]  " + Path(Path(filepath).parent, Path(filepath).stem.replace("-C", "")))
        targer_file.append(Path(Path(filepath).parent, Path(filepath).stem.replace("-C", "")))


# 到处文件到excel
def export_file(source_dir_path):
    """
    :param source_dir_path: 导出视频文件到excel里面
    :return: excel文件
    """
    source_file_name = []
    # 获取源文件夹下的所有视频文件
    for item_file in Path(source_dir_path).walk(filter=FILES):
        if item_file.ext.lower() in video_type:
            print('---> {0}'.format(item_file))
            temp_data = {}
            temp_data['原名称'] = item_file.name
            temp_data['新名称'] = item_file.name
            source_file_name.append(temp_data)
    writeExcel(source_file_name, "export_file", [u'原名称', u'新名称'], True, "./data")
    print("[*]============================处理完成==========================")


# 根据文本删除
def delete_file_with_text(txt_file_path, del_local):
    """
    从文本上读取数据并且删除
    :param txt_file_path: 文件路径
    :param del_local: true:删除本地文件，false:删除云端文件
    :return:
    """
    f = open(Path(txt_file_path), 'r', encoding='utf8')  # 返回一个文件对象
    line = f.readline()  # 调用文件的 readline()方法，一次读取一行
    while line:
        new_line = line.replace("\n", "")
        # 没有数据跳过
        if len(new_line) == 0:
            continue
        print('[-] {}'.format(new_line))
        line = f.readline()
        new_file_path = Path(new_line)
        # 如果文件夹不存在就跳过
        if not new_file_path.exists():
            continue
        new_file_path.remove()
        if del_local and Path(new_file_path + '.laoji'):
            Path(new_file_path + '.laoji').remove()

    f.close()


# 删除没有视频文件的目录
def delete_dir_no_movie(root_dir_path):
    """
    删除没有视频文件的目录
    :param root_dir_path: 根目录
    :return:
    """
    root_dir_path = Path(root_dir_path)
    # 获取子目录
    dirs = root_dir_path.listdir()
    dir_index = 0
    dir_count = str(len(dirs))
    print('[+]找到 {0} 文件夹'.format(dir_count))
    error_list = []
    for dir_name in dirs:
        dir_index = dir_index + 1
        percentage = '{}%'.format(str(dir_index / int(dir_count) * 100)[:4])
        print('[!] ------------- ' + percentage + ' [' + str(dir_index) + '/' + dir_count + '] ------------- ' + dir_name)

        # 视频文件数量计数
        temp_move_file_count = 0
        for item_file_name in dir_name.walk(filter=FILES):
            # 视频文件
            if Path(item_file_name).ext.lower() in video_type:
                temp_move_file_count = temp_move_file_count + 1
        if temp_move_file_count == 0:
            dir_name.rmtree()
    print("[*]============================处理完成==========================")


# 比较两个目录下的子目录是否重复
def compare_dir(source_dir, targer_dir):
    """
    1、比较两个目录下的子目录是否重复
    :param source_dir: 源文件夹
    :param targer_dir: 目标文件夹
    """
    source_dir_arr = set([])
    targer_dir_arr = set([])

    # 加载所有的文件夹名
    for item in Path(source_dir).walk(filter=DIRS):
        print(item)
        source_dir_arr.add(item.name)

    # 加载所有的文件夹名
    for item in Path(targer_dir).walk(filter=DIRS):
        print(item)
        targer_dir_arr.add(item.name)

    source_dir_arr_result = source_dir_arr - targer_dir_arr
    targer_dir_arr_result = targer_dir_arr - source_dir_arr
    print("[*] ****************** 目标文件夹有，源文件夹没有 ***********************")
    for item in source_dir_arr_result:
        print(item)

    print("[*] ****************** 源文件夹有，目标文件夹没有 ***********************")
    for item in targer_dir_arr_result:
        print(item)


# 比较两个目录下的文件相互的差异
def compare_file_diff_dir(source_dir_path, targer_dir_list):
    """
    1、比较两个目录下的文件相互的差异
    :param source_dir_path: 源目录
    :param targer_dir_list: 目标目录
    """
    source_file_arr = set([])
    targer_file_arr = set([])
    source_file_dict = dict()
    targer_file_dict = dict()

    # 查找所有的以 .laoji为后缀的文件，加入到集合当中
    for item_file in Path(source_dir_path).walk(filter=FILES):
        print("[S] {}".format(item_file))
        if item_file.ext.lower() not in video_type:
            continue
        source_file_arr.add(str(item_file.name))
        source_file_dict.setdefault(str(item_file.name), str(item_file))

    for item_file in Path(targer_dir_list).walk(filter=FILES):
        print("[T] {}".format(item_file))
        if item_file.ext.lower() not in video_type:
            continue
        targer_file_arr.add(str(item_file.name))
        targer_file_dict.setdefault(str(item_file.name), str(item_file))

    source_dir_arr_result = source_file_arr - targer_file_arr
    targer_dir_arr_result = targer_file_arr - source_file_arr

    with open('./scrapy_result/两个文件夹比对.text', 'w+', encoding='utf-8') as file:
        print("[*] *****************************************")
        print("[*] *****************************************")
        file.write('-------------------------------\n')
        file.write('本地存在而云盘不存在 \n')
        file.write('-------------------------------\n')
        for item in source_dir_arr_result:
            print("{} --> {}".format(item, source_file_dict.get(item)))
            file.write(source_file_dict.get(item) + '\n')

        print("[*] *****************************************")
        print("[*] *****************************************")
        file.write('-------------------------------\n')
        file.write('云盘存在而本地不存在 \n')
        file.write('-------------------------------\n')
        for item in targer_dir_arr_result:
            print("{} --> {}".format(item, targer_file_dict.get(item)))
            file.write(targer_file_dict.get(item) + '\n')


# 相同目录下的文件是否重复
def compare_file_same_dir(txt_file_path):
    """
    1、相同目录下的文件是否重复
    :param txt_file_path: 文件列表
    :return:
    """
    find_result = dict()
    final_result = dict()

    reg = re.compile(r'-CD\d+', re.IGNORECASE)

    f = open(Path(txt_file_path), 'r', encoding='utf8')  # 返回一个文件对象
    line = f.readline()  # 调用文件的 readline()方法，一次读取一行
    while line:
        # 文件名称
        old_file_name = Path(line.replace("\n", "")).stem
        print("[+] {}".format(old_file_name))

        # 删除-CD1这种形式
        temp_file_name = reg.sub('', old_file_name)

        # 分割字符串
        split_string = temp_file_name.split("-")

        # 删除字幕
        if 'C' in split_string:
            # 删除字幕
            split_string.remove('C')

        # 删除4K
        if '4K' in split_string:
            # 删除字幕
            split_string.remove('4K')

        new_file_name = '-'.join(split_string)
        # 已经存在就加入
        if new_file_name in find_result.keys():
            find_result.get(new_file_name).append(old_file_name)
        else:
            find_result.setdefault(new_file_name, [old_file_name])
        line = f.readline()
    f.close()

    # 删除集合中只包含自己的
    for item_key in find_result.keys():
        # 如果列表中只包含自己就删除
        if len(find_result.get(item_key)) == 1:
            continue

        final_result.setdefault(item_key, find_result.get(item_key))

    with open(r'./scrapy_result/file_list_result.json', 'w+', encoding='utf-8') as file:
        file.write(json.dumps(final_result, ensure_ascii=False))


# 删除目录下的所有视频文件
def remove_source_video_file(youma):
    """
    1、删除目录下的所有视频文件
    :param youma: true:有码，false:无码
    :return:
    """
    # 加载数据
    with open(local_json_file_path, 'r', encoding='utf-8') as file:
        will_process_file_mapping = json.load(file)

    for item in will_process_file_mapping:
        # 构建本地路径
        temp_local_dir_path = ""
        if youma:
            temp_local_dir_path = Path(local_youma_dir_path, item['dir_name'])
        else:
            temp_local_dir_path = Path(local_wuma_dir_path, item['dir_name'])

        # 获取所有的视频文件做映射
        for item_file_path in Path(temp_local_dir_path).walk(filter=FILES):
            # 视频文件类型
            if item_file_path.ext.lower() in video_type:
                print("[D]  {}".format(item_file_path))
                # 删除视频文件
                item_file_path.remove()

            # 删除软连接
            if item_file_path.islink():
                print("[L]  {}".format(item_file_path))
                item.remove()


# 将网盘的文件镜像到本地
def mirror_copy(cloud_root_dir_path, local_root_dir_path):
    """
    1、将网盘的文件镜像到本地
    :param cloud_root_dir_path: 网盘路径
    :param local_root_dir_path: 本地路径
    :return:
    """
    # 获取文件夹下的所有文件
    for item_file in Path(cloud_root_dir_path).walk(filter=FILES):
        # 替换路径
        target_file_path = Path(item_file.replace(cloud_root_dir_path, local_root_dir_path))
        # 文件已经存在
        if target_file_path.exists():
            print("[!]  " + target_file_path)
            continue
        try:
            target_file_path.parent.mkdir(True)
            # 视频文件
            if target_file_path.ext.lower() in video_type:
                print("[+]  " + target_file_path)
                # 创建新文件
                # file_stream = open(target_file_path, "wb", buffering=0)
                # file_stream.close()
                if target_file_path.stem.upper().__contains__("-4K"):
                    Path("./scrapy_result/source_move_file-4K.mp4").copy(target_file_path)
                else:
                    Path("./scrapy_result/source_move_file.mkv").copy(target_file_path)
                continue
        except Exception as ex:
            print("[#] #################")
            print("[#] " + repr(ex))
            print("[#] #################")
            # targer_file_path.rmtree(True)


# 将文本上的文件移动到指定的文件夹
def move_file_targer_dir_with_text(target_dir_path):
    """
    将文本上的文件移动到指定的文件夹
    :param target_dir_path: 根目录
    :return:
    """
    f = open(Path(r'./scrapy_result/movie_file.text'), 'r', encoding='utf8')  # 返回一个文件对象
    line = f.readline()  # 调用文件的 readline()方法，一次读取一行
    while line:
        new_line = line.replace("\n", "")
        # 没有数据跳过
        if len(new_line) == 0:
            continue
        print('[-] {}'.format(new_line))
        line = f.readline()
        new_file_path = Path(new_line)
        # 如果文件夹不存在就跳过
        if not new_file_path.exists():
            continue
        new_file_path.move(target_dir_path)
    f.close()


# https://www.jb51.net/article/170248.htm
# pip install -r requirements.txt #使用requirements.txt安装依赖的方式：
# pip install pipreqs #安装
# pipreqs . --encoding=utf8 --force # 在当前目录生成
# python .\jav_process.py
if __name__ == '__main__':
    # 1、将115的数据奖项
    # Y:\115\影视剧集\数据工厂\脏数据
    # mirror_copy(r'Y:\115\数据工厂\脏数据', r"E:\临时文件\meta-data")

    # 2、检查刮削的文件是否符合标准
    # check_movie_info(r"E:\临时文件\数据工厂\success")

    # 3、增加虚拟文件 已.laoji为后缀的文件
    edit_ext(r'E:\临时文件\数据工厂\success')
    # back_edit_ext(r'E:\emby\艺术视频\无码艺术')

    # 删除视频文件和软连接
    # remove_source_video_file(True)

    # 映射文件
    # E:\emby\有码艺术  E:\emby\无码艺术
    # mapping_file_with_json(True)
    # mapping_file_with_video(True)
    # mapping_file_local(r'E:\临时文件\数据工厂\等待上传', r'E:\临时文件\优蛋网盘\souce-video.mp4')

    # ===============
    # 我的工具
    # ===============
    # 删除软连接
    # remove_lik(r'E:\emby\有码艺术')

    # 比较两个目录下的子目录是否重复
    # compare_dir(r'/Users/armyant/Documents/001/001', r'/Users/armyant/Documents/001/002')

    # 比较两个目录下的文件相互的差异
    # compare_file_diff_dir(r'E:\emby\艺术视频\无码艺术', r'Y:\115\艺术视频\无码艺术')

    # 相同目录下文件重复
    # compare_file_same_dir(r'./scrapy_result/file_list.txt')

    # 根据文本删除文件
    # delete_file_with_text(r'./scrapy_result/del.txt', True)

    # 删除没有视频文件的目录
    # delete_dir_no_movie(r'E:\emby\艺术视频\FC2')

    # 移动文件到指定目录
    # move_file_targer_dir_with_text(r'Y:\115\数据工厂\临时存储')

    # ===============
    # 已经弃用，但是代码留着有用
    # ===============
    # 从文本中读取信息
    # get_txt_content("mdc_20231121T222605")
    # 暂时弃用
    # export_file(r'Y:\优蛋网盘\影视剧集\数据工厂\脏数据')
